Termination w.r.t. Q proof of TRS/TRCSREx1_2_AEL03

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> FROM₁(proper₁(X))
ACTIVE₁(from₁(X)) -> FROM₁(active₁(X))
PROPER₁(negrecip₁(X)) -> NEGRECIP₁(proper₁(X))
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(X1, active₁(X2))
S₁(mark₁(X)) -> S₁(X)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(X1, active₁(X2))
ACTIVE₁(square₁(X)) -> SQUARE₁(active₁(X))
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(pi₁(X)) -> PI₁(proper₁(X))
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(pi₁(X)) -> PI₁(active₁(X))
ACTIVE₁(pi₁(X)) -> 2NDSPOS₂(X, from₁(0))
ACTIVE₁(times₂(s₁(X), Y)) -> TIMES₂(X, Y)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(active₁(X1), X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(X1, active₁(X2))
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> SQUARE₁(proper₁(X))
PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(active₁(X1), X2)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> RCONS₂(negrecip₁(Y), 2ndspos₂(N, Z))
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> NEGRECIP₁(active₁(X))
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> POSRECIP₁(Y)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> RCONS₂(posrecip₁(Y), 2ndsneg₂(N, Z))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(proper₁(X1), proper₁(X2))
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> 2NDSNEG₂(N, Z)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)
ACTIVE₁(times₂(s₁(X), Y)) -> PLUS₂(Y, times₂(X, Y))
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(active₁(X1), X2)
PI₁(ok₁(X)) -> PI₁(X)
ACTIVE₁(cons₂(X1, X2)) -> CONS₂(active₁(X1), X2)
RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(pi₁(X)) -> PROPER₁(X)
ACTIVE₁(pi₁(X)) -> FROM₁(0)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> NEGRECIP₁(Y)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
TOP₁(ok₁(X)) -> TOP₁(active₁(X))
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
PROPER₁(times₂(X1, X2)) -> TIMES₂(proper₁(X1), proper₁(X2))
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> FROM₁(s₁(X))
PROPER₁(posrecip₁(X)) -> POSRECIP₁(proper₁(X))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(active₁(X1), X2)
NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(active₁(X1), X2)
2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(X1, active₁(X2))
FROM₁(mark₁(X)) -> FROM₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
TOP₁(ok₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
ACTIVE₁(s₁(X)) -> S₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(proper₁(X1), proper₁(X2))
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
TOP₁(mark₁(X)) -> PROPER₁(X)
ACTIVE₁(square₁(X)) -> TIMES₂(X, X)
PI₁(mark₁(X)) -> PI₁(X)
PROPER₁(rcons₂(X1, X2)) -> RCONS₂(proper₁(X1), proper₁(X2))
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
PROPER₁(s₁(X)) -> S₁(proper₁(X))
S₁(ok₁(X)) -> S₁(X)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
SQUARE₁(ok₁(X)) -> SQUARE₁(X)
ACTIVE₁(from₁(X)) -> CONS₂(X, from₁(s₁(X)))
CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> 2NDSPOS₂(N, Z)
ACTIVE₁(plus₂(s₁(X), Y)) -> PLUS₂(X, Y)
PROPER₁(plus₂(X1, X2)) -> PLUS₂(proper₁(X1), proper₁(X2))
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
ACTIVE₁(posrecip₁(X)) -> POSRECIP₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> S₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)
PROPER₁(cons₂(X1, X2)) -> CONS₂(proper₁(X1), proper₁(X2))
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)
ACTIVE₁(plus₂(s₁(X), Y)) -> S₁(plus₂(X, Y))
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> FROM₁(proper₁(X))
ACTIVE₁(from₁(X)) -> FROM₁(active₁(X))
PROPER₁(negrecip₁(X)) -> NEGRECIP₁(proper₁(X))
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(X1, active₁(X2))
S₁(mark₁(X)) -> S₁(X)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(X1, active₁(X2))
ACTIVE₁(square₁(X)) -> SQUARE₁(active₁(X))
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(pi₁(X)) -> PI₁(proper₁(X))
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(pi₁(X)) -> PI₁(active₁(X))
ACTIVE₁(pi₁(X)) -> 2NDSPOS₂(X, from₁(0))
ACTIVE₁(times₂(s₁(X), Y)) -> TIMES₂(X, Y)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(active₁(X1), X2)
ACTIVE₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(X1, active₁(X2))
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> SQUARE₁(proper₁(X))
PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(times₂(X1, X2)) -> TIMES₂(active₁(X1), X2)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> RCONS₂(negrecip₁(Y), 2ndspos₂(N, Z))
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> NEGRECIP₁(active₁(X))
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> POSRECIP₁(Y)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> RCONS₂(posrecip₁(Y), 2ndsneg₂(N, Z))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(proper₁(X1), proper₁(X2))
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> 2NDSNEG₂(N, Z)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)
ACTIVE₁(times₂(s₁(X), Y)) -> PLUS₂(Y, times₂(X, Y))
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(X1, active₁(X2))
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> 2NDSNEG₂(active₁(X1), X2)
PI₁(ok₁(X)) -> PI₁(X)
ACTIVE₁(cons₂(X1, X2)) -> CONS₂(active₁(X1), X2)
RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
PROPER₁(pi₁(X)) -> PROPER₁(X)
ACTIVE₁(pi₁(X)) -> FROM₁(0)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> NEGRECIP₁(Y)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
TOP₁(ok₁(X)) -> TOP₁(active₁(X))
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
PROPER₁(times₂(X1, X2)) -> TIMES₂(proper₁(X1), proper₁(X2))
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> FROM₁(s₁(X))
PROPER₁(posrecip₁(X)) -> POSRECIP₁(proper₁(X))
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> PLUS₂(active₁(X1), X2)
NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(active₁(X1), X2)
2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> RCONS₂(X1, active₁(X2))
FROM₁(mark₁(X)) -> FROM₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
TOP₁(ok₁(X)) -> ACTIVE₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
ACTIVE₁(s₁(X)) -> S₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> 2NDSPOS₂(proper₁(X1), proper₁(X2))
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
TOP₁(mark₁(X)) -> PROPER₁(X)
ACTIVE₁(square₁(X)) -> TIMES₂(X, X)
PI₁(mark₁(X)) -> PI₁(X)
PROPER₁(rcons₂(X1, X2)) -> RCONS₂(proper₁(X1), proper₁(X2))
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
PROPER₁(s₁(X)) -> S₁(proper₁(X))
S₁(ok₁(X)) -> S₁(X)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
SQUARE₁(ok₁(X)) -> SQUARE₁(X)
ACTIVE₁(from₁(X)) -> CONS₂(X, from₁(s₁(X)))
CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> 2NDSPOS₂(N, Z)
ACTIVE₁(plus₂(s₁(X), Y)) -> PLUS₂(X, Y)
PROPER₁(plus₂(X1, X2)) -> PLUS₂(proper₁(X1), proper₁(X2))
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
ACTIVE₁(posrecip₁(X)) -> POSRECIP₁(active₁(X))
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
ACTIVE₁(from₁(X)) -> S₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)
PROPER₁(cons₂(X1, X2)) -> CONS₂(proper₁(X1), proper₁(X2))
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)
ACTIVE₁(plus₂(s₁(X), Y)) -> S₁(plus₂(X, Y))
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 15 SCCs with 47 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQUARE₁(ok₁(X)) -> SQUARE₁(X)
SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SQUARE₁(ok₁(X)) -> SQUARE₁(X)

The remaining pairs can at least be oriented weakly.

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(SQUARE₁(x₁)) = x₁
POL(mark₁(x₁)) = x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

SQUARE₁(mark₁(X)) -> SQUARE₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(SQUARE₁(x₁)) = 2·x₁
POL(mark₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)
TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(ok₁(X1), ok₁(X2)) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(TIMES₂(x₁, x₂)) = x₁
POL(mark₁(x₁)) = x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)
TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(mark₁(X1), X2) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(TIMES₂(x₁, x₂)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

TIMES₂(X1, mark₁(X2)) -> TIMES₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(TIMES₂(x₁, x₂)) = 2·x₂
POL(mark₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)
PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(mark₁(X1), X2) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(PLUS₂(x₁, x₂)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)
PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(X1, mark₁(X2)) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(PLUS₂(x₁, x₂)) = 2·x₁ + x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PLUS₂(ok₁(X1), ok₁(X2)) -> PLUS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(PLUS₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(ok₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PI₁(mark₁(X)) -> PI₁(X)
PI₁(ok₁(X)) -> PI₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PI₁(mark₁(X)) -> PI₁(X)

The remaining pairs can at least be oriented weakly.

PI₁(ok₁(X)) -> PI₁(X)

Used ordering: Polynomial interpretation [21]:

POL(PI₁(x₁)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PI₁(ok₁(X)) -> PI₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PI₁(ok₁(X)) -> PI₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(PI₁(x₁)) = 2·x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(X1, mark₁(X2)) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(2NDSNEG₂(x₁, x₂)) = x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)
2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(mark₁(X1), X2) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(2NDSNEG₂(x₁, x₂)) = x₁ + 2·x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSNEG₂(ok₁(X1), ok₁(X2)) -> 2NDSNEG₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(2NDSNEG₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(ok₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(mark₁(X1), X2) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(2NDSPOS₂(x₁, x₂)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)
2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(X1, mark₁(X2)) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(2NDSPOS₂(x₁, x₂)) = 2·x₁ + x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

2NDSPOS₂(ok₁(X1), ok₁(X2)) -> 2NDSPOS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(2NDSPOS₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(ok₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM₁(mark₁(X)) -> FROM₁(X)
FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

FROM₁(mark₁(X)) -> FROM₁(X)

The remaining pairs can at least be oriented weakly.

FROM₁(ok₁(X)) -> FROM₁(X)

Used ordering: Polynomial interpretation [21]:

POL(FROM₁(x₁)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

FROM₁(ok₁(X)) -> FROM₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

FROM₁(ok₁(X)) -> FROM₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(FROM₁(x₁)) = 2·x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(X1, mark₁(X2)) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(RCONS₂(x₁, x₂)) = x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)
RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(ok₁(X1), ok₁(X2)) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(RCONS₂(x₁, x₂)) = x₁
POL(mark₁(x₁)) = x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

RCONS₂(mark₁(X1), X2) -> RCONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(RCONS₂(x₁, x₂)) = 2·x₁
POL(mark₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)
CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS₂(mark₁(X1), X2) -> CONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

Used ordering: Polynomial interpretation [21]:

POL(CONS₂(x₁, x₂)) = x₁ + 2·x₂
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

CONS₂(ok₁(X1), ok₁(X2)) -> CONS₂(X1, X2)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(CONS₂(x₁, x₂)) = 2·x₁ + 2·x₂
POL(ok₁(x₁)) = 2 + x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)
NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

NEGRECIP₁(mark₁(X)) -> NEGRECIP₁(X)

The remaining pairs can at least be oriented weakly.

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

Used ordering: Polynomial interpretation [21]:

POL(NEGRECIP₁(x₁)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

NEGRECIP₁(ok₁(X)) -> NEGRECIP₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(NEGRECIP₁(x₁)) = 2·x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)
POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

POSRECIP₁(mark₁(X)) -> POSRECIP₁(X)

The remaining pairs can at least be oriented weakly.

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

Used ordering: Polynomial interpretation [21]:

POL(POSRECIP₁(x₁)) = x₁
POL(mark₁(x₁)) = 1 + 2·x₁
POL(ok₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

POSRECIP₁(ok₁(X)) -> POSRECIP₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(POSRECIP₁(x₁)) = 2·x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S₁(ok₁(X)) -> S₁(X)
S₁(mark₁(X)) -> S₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

S₁(ok₁(X)) -> S₁(X)

The remaining pairs can at least be oriented weakly.

S₁(mark₁(X)) -> S₁(X)

Used ordering: Polynomial interpretation [21]:

POL(S₁(x₁)) = x₁
POL(mark₁(x₁)) = x₁
POL(ok₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

S₁(mark₁(X)) -> S₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

S₁(mark₁(X)) -> S₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(S₁(x₁)) = 2·x₁
POL(mark₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(pi₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(pi₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = x₁ + x₂
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(pi₁(x₁)) = 1 + 2·x₁
POL(plus₂(x₁, x₂)) = x₁ + x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(cons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(cons₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(plus₂(x₁, x₂)) = x₁ + x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(plus₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(plus₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(plus₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(times₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(times₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = 1 + x₁ + 2·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(s₁(X)) -> PROPER₁(X)
PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(s₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = 1 + 2·x₁
POL(square₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(square₁(X)) -> PROPER₁(X)
PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(square₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(square₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(from₁(X)) -> PROPER₁(X)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(from₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(from₁(x₁)) = 1 + 2·x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(2ndsneg₂(X1, X2)) -> PROPER₁(X2)

The remaining pairs can at least be oriented weakly.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(PROPER₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(2ndspos₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

Used ordering: Polynomial interpretation [21]:

POL(2ndspos₂(x₁, x₂)) = 1 + x₁ + 2·x₂
POL(PROPER₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X2)
PROPER₁(rcons₂(X1, X2)) -> PROPER₁(X1)

The remaining pairs can at least be oriented weakly.

PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(PROPER₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = 1 + x₁ + 2·x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(negrecip₁(X)) -> PROPER₁(X)
PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(negrecip₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

Used ordering: Polynomial interpretation [21]:

POL(PROPER₁(x₁)) = x₁
POL(negrecip₁(x₁)) = 1 + 2·x₁
POL(posrecip₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

PROPER₁(posrecip₁(X)) -> PROPER₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(PROPER₁(x₁)) = 2·x₁
POL(posrecip₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ PisEmptyProof

          ↳ QDP

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(cons₂(X1, X2)) -> ACTIVE₁(X1)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = x₁ + x₂
POL(ACTIVE₁(x₁)) = x₁
POL(cons₂(x₁, x₂)) = 1 + 2·x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(plus₂(x₁, x₂)) = x₁ + x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndspos₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(2ndspos₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(plus₂(x₁, x₂)) = x₁ + x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(plus₂(X1, X2)) -> ACTIVE₁(X1)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = x₁ + x₂
POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(plus₂(x₁, x₂)) = 1 + x₁ + 2·x₂
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(2ndsneg₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(2ndsneg₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(negrecip₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(negrecip₁(x₁)) = 1 + 2·x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(times₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = x₁
POL(times₂(x₁, x₂)) = 1 + 2·x₁ + x₂

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(square₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = x₁ + x₂
POL(s₁(x₁)) = x₁
POL(square₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X1)
ACTIVE₁(rcons₂(X1, X2)) -> ACTIVE₁(X2)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(rcons₂(x₁, x₂)) = 1 + 2·x₁ + x₂
POL(s₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)
ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(from₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(from₁(x₁)) = 1 + 2·x₁
POL(pi₁(x₁)) = x₁
POL(posrecip₁(x₁)) = x₁
POL(s₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(pi₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)
ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(pi₁(x₁)) = 1 + 2·x₁
POL(posrecip₁(x₁)) = x₁
POL(s₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)
ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(posrecip₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = x₁
POL(posrecip₁(x₁)) = 1 + 2·x₁
POL(s₁(x₁)) = x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

ACTIVE₁(s₁(X)) -> ACTIVE₁(X)

The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [21]:

POL(ACTIVE₁(x₁)) = 2·x₁
POL(s₁(x₁)) = 1 + 2·x₁

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

            ↳ QDPOrderProof

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ QDPOrderProof

                          ↳ QDP

                            ↳ QDPOrderProof

                              ↳ QDP

                                ↳ QDPOrderProof

                                  ↳ QDP

                                    ↳ QDPOrderProof

                                      ↳ QDP

                                        ↳ QDPOrderProof

                                          ↳ QDP

                                            ↳ QDPOrderProof

                                              ↳ QDP

                                                ↳ QDPOrderProof

                                                  ↳ QDP

                                                    ↳ QDPOrderProof

                                                      ↳ QDP

                                                        ↳ QDPOrderProof

                                                          ↳ QDP

                                                            ↳ PisEmptyProof

          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ AND

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

TOP₁(ok₁(X)) -> TOP₁(active₁(X))
TOP₁(mark₁(X)) -> TOP₁(proper₁(X))

The TRS R consists of the following rules:

active₁(from₁(X)) -> mark₁(cons₂(X, from₁(s₁(X))))
active₁(2ndspos₂(0, Z)) -> mark₁(rnil)
active₁(2ndspos₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(posrecip₁(Y), 2ndsneg₂(N, Z)))
active₁(2ndsneg₂(0, Z)) -> mark₁(rnil)
active₁(2ndsneg₂(s₁(N), cons₂(X, cons₂(Y, Z)))) -> mark₁(rcons₂(negrecip₁(Y), 2ndspos₂(N, Z)))
active₁(pi₁(X)) -> mark₁(2ndspos₂(X, from₁(0)))
active₁(plus₂(0, Y)) -> mark₁(Y)
active₁(plus₂(s₁(X), Y)) -> mark₁(s₁(plus₂(X, Y)))
active₁(times₂(0, Y)) -> mark₁(0)
active₁(times₂(s₁(X), Y)) -> mark₁(plus₂(Y, times₂(X, Y)))
active₁(square₁(X)) -> mark₁(times₂(X, X))
active₁(s₁(X)) -> s₁(active₁(X))
active₁(posrecip₁(X)) -> posrecip₁(active₁(X))
active₁(negrecip₁(X)) -> negrecip₁(active₁(X))
active₁(cons₂(X1, X2)) -> cons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(active₁(X1), X2)
active₁(rcons₂(X1, X2)) -> rcons₂(X1, active₁(X2))
active₁(from₁(X)) -> from₁(active₁(X))
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(active₁(X1), X2)
active₁(2ndspos₂(X1, X2)) -> 2ndspos₂(X1, active₁(X2))
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(active₁(X1), X2)
active₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(X1, active₁(X2))
active₁(pi₁(X)) -> pi₁(active₁(X))
active₁(plus₂(X1, X2)) -> plus₂(active₁(X1), X2)
active₁(plus₂(X1, X2)) -> plus₂(X1, active₁(X2))
active₁(times₂(X1, X2)) -> times₂(active₁(X1), X2)
active₁(times₂(X1, X2)) -> times₂(X1, active₁(X2))
active₁(square₁(X)) -> square₁(active₁(X))
s₁(mark₁(X)) -> mark₁(s₁(X))
posrecip₁(mark₁(X)) -> mark₁(posrecip₁(X))
negrecip₁(mark₁(X)) -> mark₁(negrecip₁(X))
cons₂(mark₁(X1), X2) -> mark₁(cons₂(X1, X2))
rcons₂(mark₁(X1), X2) -> mark₁(rcons₂(X1, X2))
rcons₂(X1, mark₁(X2)) -> mark₁(rcons₂(X1, X2))
from₁(mark₁(X)) -> mark₁(from₁(X))
2ndspos₂(mark₁(X1), X2) -> mark₁(2ndspos₂(X1, X2))
2ndspos₂(X1, mark₁(X2)) -> mark₁(2ndspos₂(X1, X2))
2ndsneg₂(mark₁(X1), X2) -> mark₁(2ndsneg₂(X1, X2))
2ndsneg₂(X1, mark₁(X2)) -> mark₁(2ndsneg₂(X1, X2))
pi₁(mark₁(X)) -> mark₁(pi₁(X))
plus₂(mark₁(X1), X2) -> mark₁(plus₂(X1, X2))
plus₂(X1, mark₁(X2)) -> mark₁(plus₂(X1, X2))
times₂(mark₁(X1), X2) -> mark₁(times₂(X1, X2))
times₂(X1, mark₁(X2)) -> mark₁(times₂(X1, X2))
square₁(mark₁(X)) -> mark₁(square₁(X))
proper₁(0) -> ok₁(0)
proper₁(s₁(X)) -> s₁(proper₁(X))
proper₁(posrecip₁(X)) -> posrecip₁(proper₁(X))
proper₁(negrecip₁(X)) -> negrecip₁(proper₁(X))
proper₁(nil) -> ok₁(nil)
proper₁(cons₂(X1, X2)) -> cons₂(proper₁(X1), proper₁(X2))
proper₁(rnil) -> ok₁(rnil)
proper₁(rcons₂(X1, X2)) -> rcons₂(proper₁(X1), proper₁(X2))
proper₁(from₁(X)) -> from₁(proper₁(X))
proper₁(2ndspos₂(X1, X2)) -> 2ndspos₂(proper₁(X1), proper₁(X2))
proper₁(2ndsneg₂(X1, X2)) -> 2ndsneg₂(proper₁(X1), proper₁(X2))
proper₁(pi₁(X)) -> pi₁(proper₁(X))
proper₁(plus₂(X1, X2)) -> plus₂(proper₁(X1), proper₁(X2))
proper₁(times₂(X1, X2)) -> times₂(proper₁(X1), proper₁(X2))
proper₁(square₁(X)) -> square₁(proper₁(X))
s₁(ok₁(X)) -> ok₁(s₁(X))
posrecip₁(ok₁(X)) -> ok₁(posrecip₁(X))
negrecip₁(ok₁(X)) -> ok₁(negrecip₁(X))
cons₂(ok₁(X1), ok₁(X2)) -> ok₁(cons₂(X1, X2))
rcons₂(ok₁(X1), ok₁(X2)) -> ok₁(rcons₂(X1, X2))
from₁(ok₁(X)) -> ok₁(from₁(X))
2ndspos₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndspos₂(X1, X2))
2ndsneg₂(ok₁(X1), ok₁(X2)) -> ok₁(2ndsneg₂(X1, X2))
pi₁(ok₁(X)) -> ok₁(pi₁(X))
plus₂(ok₁(X1), ok₁(X2)) -> ok₁(plus₂(X1, X2))
times₂(ok₁(X1), ok₁(X2)) -> ok₁(times₂(X1, X2))
square₁(ok₁(X)) -> ok₁(square₁(X))
top₁(mark₁(X)) -> top₁(proper₁(X))
top₁(ok₁(X)) -> top₁(active₁(X))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.